home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / gnu / djgpp / src / gas-211 / gas / config / tc-sh.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-30  |  27.3 KB  |  1,359 lines
  1. /* tc-sh.c -- Assemble code for the Hitachi Super-H
  2.  
  3.    Copyright (C) 1993 Free Software Foundation.
  4.  
  5.    This file is part of GAS, the GNU Assembler.
  6.  
  7.    GAS is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2, or (at your option)
  10.    any later version.
  11.  
  12.    GAS is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License
  18.    along with GAS; see the file COPYING.  If not, write to
  19.    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /*
  22.   Written By Steve Chamberlain
  23.   sac@cygnus.com
  24.   */
  25.  
  26. #include <stdio.h>
  27. #include "as.h"
  28. #include "bfd.h"
  29. #include "subsegs.h"
  30. #define DEFINE_TABLE
  31. #include "../opcodes/sh-opc.h"
  32. #include <ctype.h>
  33.  
  34. const char comment_chars[] = "!";
  35. const char line_separator_chars[] = ";";
  36. const char line_comment_chars[] = "!";
  37.  
  38. /* This table describes all the machine specific pseudo-ops the assembler
  39.    has to support.  The fields are:
  40.    pseudo-op name without dot
  41.    function to call to execute this pseudo-op
  42.    Integer arg to pass to the function
  43.    */
  44.  
  45. void cons ();
  46. void s_align_bytes();
  47.  
  48. const pseudo_typeS md_pseudo_table[] =
  49. {
  50.   {"int", cons, 4},
  51.   {"data.b", cons, 1},
  52.   {"data.w", cons, 2},
  53.   {"data.l", cons, 4},
  54.   {"form", listing_psize, 0},
  55.   {"heading", listing_title, 0},
  56.   {"import", s_ignore, 0},
  57.   {"page", listing_eject, 0},
  58.   {"program", s_ignore, 0},
  59. /*  {"align", s_align_bytes, 0},*/
  60.   {0, 0, 0}
  61. };
  62.  
  63. /*int md_reloc_size;*/
  64.  
  65. static int relax; /* set if -relax seen */
  66.  
  67. const char EXP_CHARS[] = "eE";
  68.  
  69. /* Chars that mean this number is a floating point constant */
  70. /* As in 0f12.456 */
  71. /* or    0d1.2345e12 */
  72. const char FLT_CHARS[] = "rRsSfFdDxXpP";
  73.  
  74. #define C(a,b) ENCODE_RELAX(a,b)
  75.  
  76. #define JREG 14      /* Register used as a temp when relaxing */
  77. #define ENCODE_RELAX(what,length) (((what) << 4) + (length))
  78. #define GET_WHAT(x) ((x>>4))
  79.  
  80. /* These are the two types of relaxable instrction */
  81. #define COND_JUMP 1
  82. #define UNCOND_JUMP  2
  83.  
  84. #define UNDEF_DISP 0
  85. #define COND8  1
  86. #define COND12 2
  87. #define COND32 3
  88. #define UNCOND12 1
  89. #define UNCOND32 2
  90. #define UNDEF_WORD_DISP 4
  91. #define END 5
  92.  
  93. #define UNCOND12 1
  94. #define UNCOND32 2
  95.  
  96. #define COND8_F 254
  97. #define COND8_M -256
  98. #define COND8_LENGTH 2
  99. #define COND12_F (4094 - 4) /* -4 since there are two extra */
  100.                   /* instructions needed */
  101. #define COND12_M -4096
  102. #define COND12_LENGTH 6
  103. #define COND32_F (1<<30)
  104. #define COND32_M -(1<<30)
  105. #define COND32_LENGTH 14
  106.  
  107. #define UNCOND12_F 4094
  108. #define UNCOND12_M -4096
  109. #define UNCOND12_LENGTH 2
  110.  
  111. #define UNCOND32_F (1<<30)
  112. #define UNCOND32_M -(1<<30)
  113. #define UNCOND32_LENGTH 14
  114.  
  115.  
  116. relax_typeS md_relax_table[C (END, 0)];
  117.  
  118. static struct hash_control *opcode_hash_control;    /* Opcode mnemonics */
  119.  
  120. /*
  121.   This function is called once, at assembler startup time.  This should
  122.   set up all the tables, etc that the MD part of the assembler needs
  123.   */
  124.  
  125. void
  126. md_begin ()
  127. {
  128.   sh_opcode_info *opcode;
  129.   char *prev_name = "";
  130.  
  131.   opcode_hash_control = hash_new ();
  132.  
  133.   /* Insert unique names into hash table */
  134.   for (opcode = sh_table; opcode->name; opcode++)
  135.     {
  136.       if (strcmp (prev_name, opcode->name))
  137.     {
  138.       prev_name = opcode->name;
  139.       hash_insert (opcode_hash_control, opcode->name, (char *) opcode);
  140.     }
  141.       else {
  142.     /* Make all the opcodes with the same name point to the same 
  143.        string */
  144.     opcode->name = prev_name;
  145.       }
  146.     }
  147.  
  148.   /* Initialize the relax table */
  149.   md_relax_table[C (COND_JUMP, COND8)].rlx_forward = COND8_F;
  150.   md_relax_table[C (COND_JUMP, COND8)].rlx_backward = COND8_M;
  151.   md_relax_table[C (COND_JUMP, COND8)].rlx_length = COND8_LENGTH;
  152.   md_relax_table[C (COND_JUMP, COND8)].rlx_more = C (COND_JUMP, COND12);
  153.  
  154.   md_relax_table[C (COND_JUMP, COND12)].rlx_forward = COND12_F;
  155.   md_relax_table[C (COND_JUMP, COND12)].rlx_backward = COND12_M;
  156.   md_relax_table[C (COND_JUMP, COND12)].rlx_length = COND12_LENGTH;
  157.   md_relax_table[C (COND_JUMP, COND12)].rlx_more = C (COND_JUMP, COND32);
  158.  
  159.   md_relax_table[C (COND_JUMP, COND32)].rlx_forward = COND32_F;
  160.   md_relax_table[C (COND_JUMP, COND32)].rlx_backward = COND32_M;
  161.   md_relax_table[C (COND_JUMP, COND32)].rlx_length = COND32_LENGTH;
  162.   md_relax_table[C (COND_JUMP, COND32)].rlx_more = 0;
  163.  
  164.  
  165.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_forward = UNCOND12_F;
  166.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_backward = UNCOND12_M;
  167.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length = UNCOND12_LENGTH;
  168.   md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_more = C (UNCOND_JUMP, UNCOND32);
  169.  
  170.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_forward = UNCOND32_F;
  171.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_backward = UNCOND32_M;
  172.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length = UNCOND32_LENGTH;
  173.   md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_more = 0;
  174.  
  175.  
  176. }
  177.  
  178. static int reg_m;
  179. static int reg_n;
  180. static expressionS immediate;    /* absolute expression */
  181.  
  182. typedef struct
  183. {
  184.   sh_arg_type type;
  185.   int reg;
  186. }
  187.  
  188. sh_operand_info;
  189.  
  190. /* try and parse a reg name, returns number of chars consumed */
  191. static int
  192. parse_reg (src, mode, reg)
  193.      char *src;
  194.      int *mode;
  195.      int *reg;
  196. {
  197.   if (src[0] == 'r')
  198.     {
  199.       if (src[1] == '1')
  200.     {
  201.       if (src[2] >= '0' && src[2] <= '5')
  202.         {
  203.           *mode = A_REG_N;
  204.           *reg = 10 + src[2] - '0';
  205.           return 3;
  206.         }
  207.     }
  208.       if (src[1] >= '0' && src[1] <= '9')
  209.     {
  210.       *mode = A_REG_N;
  211.       *reg = (src[1] - '0');
  212.       return 2;
  213.     }
  214.     }
  215.  
  216.   if (src[0] == 's' && src[1] == 'r')
  217.     {
  218.       *mode = A_SR;
  219.       return 2;
  220.     }
  221.  
  222.   if (src[0] == 's' && src[1] == 'p')
  223.     {
  224.       *mode = A_REG_N;
  225.       *reg = 15;
  226.       return 2;
  227.     }
  228.  
  229.   if (src[0] == 'p' && src[1] == 'r')
  230.     {
  231.       *mode = A_PR;
  232.       return 2;
  233.     }
  234.   if (src[0] == 'p' && src[1] == 'c')
  235.     {
  236.       *mode = A_DISP_PC;
  237.       return 2;
  238.     }
  239.   if (src[0] == 'g' && src[1] == 'b' && src[2] == 'r')
  240.     {
  241.       *mode = A_GBR;
  242.       return 3;
  243.     }
  244.   if (src[0] == 'v' && src[1] == 'b' && src[2] == 'r')
  245.     {
  246.       *mode = A_VBR;
  247.       return 3;
  248.     }
  249.  
  250.   if (src[0] == 'm' && src[1] == 'a' && src[2] == 'c')
  251.     {
  252.       if (src[3] == 'l')
  253.     {
  254.       *mode = A_MACL;
  255.       return 4;
  256.     }
  257.       if (src[3] == 'h')
  258.     {
  259.       *mode = A_MACH;
  260.       return 4;
  261.     }
  262.     }
  263.  
  264.  
  265.   return 0;
  266. }
  267.  
  268. static
  269. char *
  270. parse_exp (s)
  271.      char *s;
  272. {
  273.   char *save;
  274.   char *new;
  275.   segT seg;
  276.  
  277.   save = input_line_pointer;
  278.  
  279.  
  280.   input_line_pointer = s;
  281.  
  282.   seg = expr (0, &immediate);
  283.   new = input_line_pointer;
  284.   input_line_pointer = save;
  285.   if (SEG_NORMAL (seg))
  286.     return new;
  287.   switch (seg)
  288.     {
  289.     case SEG_ABSOLUTE:
  290.     case SEG_UNKNOWN:
  291.     case SEG_DIFFERENCE:
  292.     case SEG_BIG:
  293.     case SEG_REGISTER:
  294.       return new;
  295.     case SEG_ABSENT:
  296.       as_bad ("Missing operand");
  297.       return new;
  298.     default:
  299.       as_bad ("Don't understand operand of type %s", segment_name (seg));
  300.       return new;
  301.     }
  302. }
  303.  
  304.  
  305. /* The many forms of operand:
  306.  
  307.    Rn            Register direct
  308.    @Rn            Register indirect
  309.    @Rn+            Autoincrement
  310.    @-Rn            Autodecrement
  311.    @(disp:4,Rn)
  312.    @(disp:8,GBR)
  313.    @(disp:8,PC)
  314.  
  315.    @(R0,Rn)
  316.    @(R0,GBR)
  317.  
  318.    disp:8
  319.    disp:12
  320.    #imm8
  321.    pr, gbr, vbr, macl, mach
  322.  
  323.  */
  324.  
  325. static
  326. char *parse_at(src, op)
  327. char *src;
  328. sh_operand_info *op;
  329. {
  330.   int len;
  331.   int mode;
  332.   src++;
  333.   if (src[0] == '-')
  334.     {
  335.       /* Must be predecrement */
  336.       src++;
  337.       
  338.       len = parse_reg (src, &mode, &(op->reg));
  339.       if (mode != A_REG_N)
  340.     as_bad ("illegal register after @-");
  341.  
  342.       op->type = A_DEC_N;
  343.       src += len;
  344.     }
  345.   else if (src[0] == '(')
  346.     {
  347.       /* Could be @(disp, rn), @(disp, gbr), @(disp, pc),  @(r0, gbr) or
  348.      @(r0, rn) */
  349.       src++;
  350.       len = parse_reg (src, &mode, &(op->reg));
  351.       if (len && mode == A_REG_N)
  352.     {
  353.       src += len;
  354.       if (op->reg != 0)
  355.         {
  356.           as_bad ("must be @(r0,...)");
  357.         }
  358.       if (src[0] == ',')
  359.         src++;
  360.       /* Now can be rn or gbr */
  361.       len = parse_reg (src, &mode, &(op->reg));
  362.       if (mode == A_GBR)
  363.         {
  364.           op->type = A_R0_GBR;
  365.         }
  366.       else if (mode == A_REG_N)
  367.         {
  368.           op->type = A_IND_R0_REG_N;
  369.         }
  370.       else
  371.         {
  372.           as_bad ("syntax error in @(r0,...)");
  373.         }
  374.     }
  375.       else
  376.     {
  377.       /* Must be an @(disp,.. thing) */
  378.       src = parse_exp (src);
  379.       if (src[0] == ',')
  380.         src++;
  381.       /* Now can be rn, gbr or pc */
  382.       len = parse_reg (src, &mode, &op->reg);
  383.       if (len)
  384.         {
  385.           if (mode == A_REG_N)
  386.         {
  387.           op->type = A_DISP_REG_N;
  388.         }
  389.           else if (mode == A_GBR)
  390.         {
  391.           op->type = A_DISP_GBR;
  392.         }
  393.           else if (mode == A_DISP_PC)
  394.         {
  395.           op->type = A_DISP_PC;
  396.         }
  397.           else
  398.         {
  399.           as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
  400.         }
  401.         }
  402.       else
  403.         {
  404.           as_bad ("syntax error in @(disp,[Rn, gbr, pc])");
  405.         }
  406.     }
  407.       src += len;
  408.       if (src[0] != ')') 
  409.     as_bad("expecting )");
  410.       else
  411.     src ++;
  412.     }
  413.   else
  414.     {
  415.       src += parse_reg (src, &mode, &(op->reg));
  416.       if (mode != A_REG_N)
  417.     {
  418.       as_bad ("illegal register after @");
  419.     }
  420.       if (src[0] == '+')
  421.     {
  422.       op->type = A_INC_N;
  423.       src++;
  424.     }
  425.       else
  426.     {
  427.       op->type = A_IND_N;
  428.     }
  429.     }
  430.   return src;
  431. }
  432.  
  433. static void
  434. get_operand (ptr, op)
  435.      char **ptr;
  436.      sh_operand_info *op;
  437. {
  438.   char *src = *ptr;
  439.   int mode = -1;
  440.   unsigned int len;
  441.  
  442.   if (src[0] == '#')
  443.     {
  444.       src++;
  445.       *ptr = parse_exp (src);
  446.       op->type = A_IMM;
  447.       return;
  448.     }
  449.  
  450.   else if (src[0] == '@')
  451.     {
  452.       *ptr = parse_at(src, op);
  453.       return;
  454.     }
  455.   len = parse_reg (src, &mode, &(op->reg));
  456.   if (len)
  457.     {
  458.       *ptr = src + len;
  459.       op->type = mode;
  460.       return;
  461.     }
  462.   else 
  463.     {
  464.     /* Not a reg, the only thing left is a displacement */
  465.     *ptr = parse_exp(src);
  466.     op->type = A_DISP_PC;
  467.     return;
  468.   }
  469. }
  470.  
  471. static
  472. char *
  473. get_operands (info, args, operand)
  474.      sh_opcode_info *info;
  475.      char *args;
  476.      sh_operand_info *operand;
  477.  
  478. {
  479.   char *ptr = args;
  480.   if (info->arg[0])
  481.     {
  482.       ptr++;
  483.       
  484.       get_operand (&ptr, operand + 0);
  485.       if (info->arg[1])
  486.     {
  487.       if (*ptr == ',')
  488.         {
  489.           ptr++;
  490.         }
  491.       get_operand (&ptr, operand + 1);
  492.     }
  493.       else
  494.     {
  495.       operand[1].type = 0;
  496.     }
  497.     }
  498.   else
  499.     {
  500.       operand[0].type = 0;
  501.       operand[1].type = 0;
  502.     }
  503.   return ptr;
  504. }
  505.  
  506. /* Passed a pointer to a list of opcodes which use different
  507.    addressing modes, return the opcode which matches the opcodes
  508.    provided
  509.    */
  510.  
  511. static
  512. sh_opcode_info *
  513. get_specific (opcode, operands)
  514.      sh_opcode_info *opcode;
  515.      sh_operand_info *operands;
  516. {
  517.   sh_opcode_info *this_try = opcode;
  518.   char *name = opcode->name;
  519.   int arg_to_test = 0;
  520.   int n = 0;
  521.   while (opcode->name)
  522.     {
  523.       this_try = opcode++;
  524.       if (this_try->name != name)
  525.     {
  526.       /* We've looked so far down the table that we've run out of
  527.          opcodes with the same name */
  528.       return 0;
  529.     }
  530.       /* look at both operands needed by the opcodes and provided by
  531.      the user - since an arg test will often fail on the same arg
  532.      again and again, we'll try and test the last failing arg the
  533.      first on each opcode try */
  534.  
  535.       for (n = 0; this_try->arg[n]; n++)
  536.     {
  537.       sh_operand_info *user = operands + arg_to_test;
  538.       sh_arg_type arg = this_try->arg[arg_to_test];
  539.       switch (arg)
  540.         {
  541.         case A_IMM:
  542.         case A_BDISP12:
  543.         case A_BDISP8:
  544.         case A_DISP_GBR:
  545.         case A_DISP_PC:
  546.         case A_MACH:
  547.         case A_PR:
  548.         case A_MACL:          
  549.           if (user->type != arg) goto fail;
  550.           break;
  551.         case A_R0:
  552.           /* opcode needs r0 */
  553.           if (user->type != A_REG_N || user->reg != 0) goto fail;
  554.         break;
  555.         case A_REG_N:
  556.         case A_INC_N:
  557.         case A_DEC_N:
  558.         case A_IND_N:
  559.         case A_IND_R0_REG_N:
  560.         case A_DISP_REG_N:
  561.           /* Opcode needs rn */
  562.           if (user->type != arg) goto fail;
  563.           reg_n = user->reg;
  564.           break;
  565.  
  566.         case A_REG_M:
  567.         case A_INC_M:
  568.         case A_DEC_M:
  569.         case A_IND_M:
  570.         case A_IND_R0_REG_M:
  571.         case A_DISP_REG_M:
  572.           /* Opcode needs rn */
  573.           if (user->type != arg  - A_REG_M + A_REG_N) goto fail;
  574.           reg_m = user->reg;
  575.           break;
  576.         default:
  577.           printf ("unhandled %d\n", arg);
  578.           goto fail;
  579.         }
  580.       /* If we did 0, test 1 next, else 0 */
  581.       arg_to_test = 1 - arg_to_test;
  582.     }
  583.       return this_try;
  584.     fail:;
  585.     }
  586.  
  587.   return 0;
  588. }
  589.  
  590. int
  591. check (operand, low, high)
  592.      expressionS *operand;
  593.      int low;
  594.      int high;
  595. {
  596.   if (operand->X_seg != SEG_ABSOLUTE
  597.       || operand->X_add_number < low
  598.       || operand->X_add_number > high)
  599.     {
  600.       as_bad ("operand must be absolute in range %d..%d", low, high);
  601.     }
  602.   return operand->X_add_number;
  603. }
  604.  
  605.  
  606. static void
  607. insert (where, how, pcrel)
  608.      char *where;
  609.      int how;
  610.      int pcrel;
  611. {
  612.   fix_new (frag_now,
  613.        where - frag_now->fr_literal,
  614.        4,
  615.        immediate.X_add_symbol,
  616.        immediate.X_subtract_symbol,
  617.        immediate.X_add_number,
  618.        pcrel,
  619.        how);
  620.  
  621. }
  622.  
  623. static void
  624. build_relax (opcode)
  625. sh_opcode_info *opcode;
  626. {
  627.   int len;
  628.   char *p;
  629.   if (opcode->arg[0] == A_BDISP8) 
  630.     {
  631.       p = frag_var(rs_machine_dependent,
  632.            md_relax_table[C(COND_JUMP, COND32)].rlx_length,
  633.            len = md_relax_table[C(COND_JUMP,  COND8)].rlx_length,
  634.            C(COND_JUMP, 0),
  635.            immediate.X_add_symbol,
  636.            immediate.X_add_number,
  637.            0);
  638.       p[0] = (opcode->nibbles[0] << 4) | (opcode->nibbles[1]);
  639.     }
  640.   else if (opcode->arg[0] == A_BDISP12) 
  641.     {
  642.       p = frag_var(rs_machine_dependent,
  643.            md_relax_table[C(UNCOND_JUMP, UNCOND32)].rlx_length,
  644.            len = md_relax_table[C(UNCOND_JUMP,  UNCOND12)].rlx_length,
  645.            C(UNCOND_JUMP, 0),
  646.            immediate.X_add_symbol,
  647.            immediate.X_add_number,
  648.            0);
  649.       p[0] = (opcode->nibbles[0] << 4) ;
  650.     }
  651.  
  652. }
  653. /* Now we know what sort of opcodes it is, lets build the bytes -
  654.  */
  655. static void
  656. build_Mytes (opcode, operand)
  657.      sh_opcode_info *opcode;
  658.      sh_operand_info *operand;
  659.  
  660. {
  661.   int index;
  662.   char nbuf[4];
  663.   char *output = frag_more (2);
  664.  
  665.   nbuf[0] = 0;
  666.   nbuf[1] = 0;
  667.   nbuf[2] = 0;
  668.   nbuf[3] = 0;
  669.  
  670.   for (index = 0; index < 4; index++)
  671.     {
  672.       sh_nibble_type i = opcode->nibbles[index];
  673.       if (i < 16)
  674.     {
  675.       nbuf[index] = i;
  676.     }
  677.       else
  678.     {
  679.       switch (i)
  680.         {
  681.         case REG_N:
  682.           nbuf[index] = reg_n;
  683.           break;
  684.         case REG_M:
  685.           nbuf[index] = reg_m;
  686.           break;
  687.         case DISP_4:
  688.           insert(output + 1, R_SH_IMM4,0);
  689.           break;
  690.         case IMM_4BY4:
  691.           insert(output + 1, R_SH_IMM4BY4,0);
  692.           break;
  693.         case IMM_4BY2:
  694.           insert(output + 1, R_SH_IMM4BY2,0);
  695.           break;
  696.         case IMM_4:
  697.           insert(output + 1, R_SH_IMM4,0);
  698.           break;
  699.         case IMM_8BY4:
  700.           insert(output + 1, R_SH_IMM8BY4,0);
  701.           break;
  702.         case IMM_8BY2:
  703.           insert(output + 1, R_SH_IMM8BY2,0);
  704.           break;
  705.         case IMM_8:
  706.           insert(output + 1, R_SH_IMM8,0);
  707.           break;
  708.         case PCRELIMM_8BY4:
  709.           insert(output + 1, R_SH_PCRELIMM8BY4,0);
  710.           break;
  711.         case PCRELIMM_8BY2:
  712.           insert(output + 1, R_SH_PCRELIMM8BY2,0);
  713.           break;
  714.         default:
  715.           printf ("failed for %d\n", i);
  716.         }
  717.     }
  718.     }
  719.   output[0] = (nbuf[0] << 4) | (nbuf[1]);
  720.   output[1] = (nbuf[2] << 4) | (nbuf[3]);
  721. }
  722.  
  723. /* This is the guts of the machine-dependent assembler.  STR points to a
  724.    machine dependent instruction.  This function is supposed to emit
  725.    the frags/bytes it assembles to.
  726.    */
  727.  
  728. void
  729. md_assemble(str)
  730.  char *str;
  731. {
  732.   unsigned  char *op_start;
  733.   unsigned  char *op_end;
  734.   sh_operand_info operand[2];
  735.   sh_opcode_info *opcode;
  736.   unsigned  char *name;
  737.  
  738.   int nlen = 0;
  739.  
  740.   /* Drop leading whitespace */
  741.   while (*str == ' ')
  742.     str++;
  743.  
  744.   /* find the op code end */
  745.   for (name = op_start = op_end = (unsigned char *)(str);
  746.        *op_end &&
  747.        !is_end_of_line[*op_end] && *op_end != ' ';
  748.        op_end++)
  749.     {
  750.       nlen++;
  751.     }
  752.   name[nlen] = 0;
  753.  
  754.   if (op_end == op_start)
  755.     {
  756.       as_bad ("can't find opcode ");
  757.     }
  758.  
  759.   opcode = (sh_opcode_info *) hash_find (opcode_hash_control, name);
  760.  
  761.   if (opcode == NULL)
  762.     {
  763.       as_bad ("unknown opcode");
  764.       return;
  765.     }
  766.  
  767.   if (opcode->arg[0] == A_BDISP12
  768.       || opcode->arg[0] == A_BDISP8) 
  769.     {
  770.       input_line_pointer = parse_exp(op_end + 1);
  771.       build_relax(opcode);
  772.     }
  773.   else 
  774.     {
  775.       input_line_pointer = get_operands (opcode, op_end, operand);
  776.  
  777.       opcode = get_specific (opcode, operand);
  778.  
  779.       if (opcode == 0)
  780.     {
  781.       /* Couldn't find an opcode which matched the operands */
  782.       char *where = frag_more (2);
  783.  
  784.       where[0] = 0x0;
  785.       where[1] = 0x0;
  786.       as_bad ("invalid operands for opcode");
  787.       return;
  788.     }
  789.  
  790.       build_Mytes (opcode, operand);
  791.     }
  792.  
  793. }
  794.  
  795. void
  796. DEFUN (tc_crawl_symbol_chain, (headers),
  797.        object_headers * headers)
  798. {
  799.   printf ("call to tc_crawl_symbol_chain \n");
  800. }
  801.  
  802. symbolS *
  803. DEFUN (md_undefined_symbol, (name),
  804.        char *name)
  805. {
  806.   return 0;
  807. }
  808.  
  809. void
  810. DEFUN (tc_headers_hook, (headers),
  811.        object_headers * headers)
  812. {
  813.   printf ("call to tc_headers_hook \n");
  814. }
  815.  
  816. void
  817. DEFUN_VOID (md_end)
  818. {
  819. }
  820.  
  821. /* Various routines to kill one day */
  822. /* Equal to MAX_PRECISION in atof-ieee.c */
  823. #define MAX_LITTLENUMS 6
  824.  
  825. /* Turn a string in input_line_pointer into a floating point constant of type
  826.    type, and store the appropriate bytes in *litP.  The number of LITTLENUMS
  827.    emitted is stored in *sizeP .  An error message is returned, or NULL on OK.
  828.    */
  829. char *
  830. md_atof (type, litP, sizeP)
  831.      char type;
  832.      char *litP;
  833.      int *sizeP;
  834. {
  835.   int prec;
  836.   LITTLENUM_TYPE words[MAX_LITTLENUMS];
  837.   LITTLENUM_TYPE *wordP;
  838.   char *t;
  839.   char *atof_ieee ();
  840.  
  841.   switch (type)
  842.     {
  843.     case 'f':
  844.     case 'F':
  845.     case 's':
  846.     case 'S':
  847.       prec = 2;
  848.       break;
  849.  
  850.     case 'd':
  851.     case 'D':
  852.     case 'r':
  853.     case 'R':
  854.       prec = 4;
  855.       break;
  856.  
  857.     case 'x':
  858.     case 'X':
  859.       prec = 6;
  860.       break;
  861.  
  862.     case 'p':
  863.     case 'P':
  864.       prec = 6;
  865.       break;
  866.  
  867.     default:
  868.       *sizeP = 0;
  869.       return "Bad call to MD_NTOF()";
  870.     }
  871.   t = atof_ieee (input_line_pointer, type, words);
  872.   if (t)
  873.     input_line_pointer = t;
  874.  
  875.   *sizeP = prec * sizeof (LITTLENUM_TYPE);
  876.   for (wordP = words; prec--;)
  877.     {
  878.       md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
  879.       litP += sizeof (LITTLENUM_TYPE);
  880.     }
  881.   return "";            /* Someone should teach Dean about null pointers */
  882. }
  883.  
  884. int
  885. md_parse_option (argP, cntP, vecP)
  886.      char **argP;
  887.      int *cntP;
  888.      char ***vecP;
  889.  
  890. {
  891.   if (!strcmp (*argP, "relax"))
  892.     {
  893.       relax = 1;
  894.       **argP =0;
  895.     }
  896.   return 1;
  897. }
  898.  
  899. int md_short_jump_size;
  900.  
  901. void
  902. tc_Nout_fix_to_chars ()
  903. {
  904.   printf ("call to tc_Nout_fix_to_chars \n");
  905.   abort ();
  906. }
  907.  
  908. void
  909. md_create_short_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
  910.      char *ptr;
  911.      long from_Nddr;
  912.      long to_Nddr;
  913.      fragS *frag;
  914.      symbolS *to_symbol;
  915. {
  916.   as_fatal ("failed sanity check.");
  917. }
  918.  
  919. void
  920. md_create_long_jump (ptr, from_Nddr, to_Nddr, frag, to_symbol)
  921.      char *ptr;
  922.      long from_Nddr, to_Nddr;
  923.      fragS *frag;
  924.      symbolS *to_symbol;
  925. {
  926.   as_fatal ("failed sanity check.");
  927. }
  928.  
  929. /*
  930. called after relaxing, change the frags so they know how big they are
  931. */
  932. void
  933. md_convert_frag (headers, fragP)
  934.      object_headers *headers;
  935.      fragS *fragP;
  936.  
  937. {
  938.   unsigned  char *buffer = (unsigned char *)(fragP->fr_fix + fragP->fr_literal);
  939.   int donerelax = 0;
  940.   int targ_addr = (S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset);  
  941.   switch (fragP->fr_subtype)
  942.     {
  943.     case C (COND_JUMP, COND8):
  944.       {
  945.     /* Get the address of the end of the instruction */
  946.     int next_inst = fragP->fr_fix + fragP->fr_address + 2;
  947.  
  948.     int disp = targ_addr - next_inst -2 ;
  949.     disp /= 2;
  950.     md_number_to_chars (buffer + 1, disp, 1);
  951.     fragP->fr_fix += 2;
  952.     fragP->fr_var = 0;
  953.       }
  954.       break;
  955.  
  956.     case C (UNCOND_JUMP, UNCOND12):
  957.       {
  958.     /* Get the address of the end of the instruction */
  959.     int next_inst = fragP->fr_fix + fragP->fr_address + 2;
  960.  
  961.     int t;
  962.     int disp = targ_addr - next_inst -2 ;
  963.  
  964.     disp /= 2;
  965.     t = buffer[0] & 0xf0;
  966.     md_number_to_chars (buffer , disp, 2);
  967.     buffer[0] = (buffer[0] & 0xf) | t;
  968.     fragP->fr_fix += 2;
  969.     fragP->fr_var = 0;
  970.       }
  971.       break;
  972.  
  973.     case C (UNCOND_JUMP, UNCOND32):
  974.     case C (UNCOND_JUMP, UNDEF_WORD_DISP):
  975.       {
  976.     /* A jump wont fit in 12 bits, make code which looks like
  977.        bra foo
  978.        mov.w @(0, PC), r14
  979.        .long disp
  980.        foo: bra @r14
  981.        */
  982.     
  983.     int next_inst =
  984.       fragP->fr_fix + fragP->fr_address + UNCOND32_LENGTH;
  985.  
  986.     int disp = targ_addr - next_inst  ;
  987.     int t = buffer[0] & 0x10;
  988.  
  989.     disp /= 2;
  990.  
  991.     buffer[0] = 0xa0;    /* branch over move and disp */
  992.     buffer[1] = 3;
  993.     buffer[2] = 0xd0 | JREG; /* Build mov insn */
  994.     buffer[3] = 0x00;
  995.  
  996.     buffer[4] = 0;        /* space for 32 bit jump disp */
  997.     buffer[5] = 0; 
  998.     buffer[6] = 0;
  999.     buffer[7] = 0;
  1000.  
  1001.     buffer[10] = 0x40 | JREG; /* Build jmp @JREG */
  1002.     buffer[11] = t ? 0xb : 0x2b ;
  1003.  
  1004.     buffer[12] = 0x20;    /* build nop */
  1005.     buffer[13] = 0x0b;
  1006.  
  1007.     /* Make reloc for the long disp */
  1008.     fix_new(fragP, 
  1009.         fragP->fr_fix + 4,
  1010.         4,
  1011.         fragP->fr_symbol,
  1012.         0,
  1013.         fragP->fr_offset, 
  1014.         0,
  1015.         R_SH_IMM32);
  1016.     fragP->fr_fix += UNCOND32_LENGTH;
  1017.     fragP->fr_var = 0;
  1018.     donerelax = 1;
  1019.     
  1020.       }
  1021.       break;
  1022.  
  1023.     case C (COND_JUMP, COND12):
  1024.       {
  1025.     /* A bcond won't fit, so turn it into a b!cond; bra disp; nop */
  1026.     int next_inst =
  1027.       fragP->fr_fix + fragP->fr_address + 6;
  1028.  
  1029.     int disp = targ_addr - next_inst  ;
  1030.     disp /= 2;
  1031.     md_number_to_chars (buffer + 2, disp, 2);
  1032.     buffer[0] ^= 0x2;    /* Toggle T/F bit */
  1033.     buffer[1] = 1;        /* branch over jump and nop */
  1034.     buffer[2] = (buffer[2] & 0xf) | 0xa0; /* Build jump insn */
  1035.     buffer[4] = 0x20;    /* Build nop */
  1036.     buffer[5] = 0x0b; 
  1037.     fragP->fr_fix += 6;
  1038.     fragP->fr_var = 0;
  1039.     donerelax = 1;
  1040.       }
  1041.       break;
  1042.  
  1043.     case C (COND_JUMP, COND32):
  1044.     case C (COND_JUMP, UNDEF_WORD_DISP):
  1045.       {
  1046.     /* A bcond won't fit and it won't go into a 12 bit 
  1047.        displacement either, the code sequence looks like:
  1048.        b!cond foop
  1049.        mov.w @(n, PC), r14
  1050.        jmp    @r14
  1051.        nop
  1052.        .long where
  1053.        foop:       
  1054.        */
  1055.     
  1056.     int next_inst =
  1057.       fragP->fr_fix + fragP->fr_address + COND32_LENGTH;
  1058.  
  1059.     int disp = targ_addr - next_inst  ;
  1060.     disp /= 2;
  1061.  
  1062.     buffer[0] ^= 0x2;    /* Toggle T/F bit */
  1063. #define JREG 14
  1064.     buffer[1] = 5;        /* branch over mov, jump, nop and ptr */
  1065.     buffer[2] = 0xd0 | JREG; /* Build mov insn */
  1066.     buffer[3] = 0x2;
  1067.     buffer[4] = 0x40 | JREG; /* Build jmp @JREG */
  1068.     buffer[5] = 0x0b; 
  1069.     buffer[6] = 0x20;    /* build nop */
  1070.     buffer[7] = 0x0b;
  1071.     buffer[8] = 0;        /* space for 32 bit jump disp */
  1072.     buffer[9] = 0; 
  1073.     buffer[10] = 0;
  1074.     buffer[11] = 0;
  1075.     buffer[12] = 0;
  1076.     buffer[13] = 0;
  1077.     /* Make reloc for the long disp */
  1078.     fix_new(fragP, 
  1079.         fragP->fr_fix + 8,
  1080.         4,
  1081.         fragP->fr_symbol,
  1082.         0,
  1083.         fragP->fr_offset, 
  1084.         0,
  1085.         R_SH_IMM32);
  1086.     fragP->fr_fix += COND32_LENGTH;
  1087.     fragP->fr_var = 0;
  1088.     donerelax = 1;
  1089.       }
  1090.       break;
  1091.  
  1092.     default:
  1093.       abort ();
  1094.     }
  1095.  
  1096.   if (donerelax && !relax) 
  1097.     {
  1098.       as_bad("Offset doesn't fit at 0x%x, trying to get to 0x%x",
  1099.          fragP->fr_address,
  1100.          targ_addr);
  1101.     }
  1102.  
  1103. }
  1104.  
  1105. long
  1106. DEFUN (md_section_align, (seg, size),
  1107.        segT seg AND
  1108.        long size)
  1109. {
  1110.   return ((size + (1 << section_alignment[(int) seg]) - 1)
  1111.       & (-1 << section_alignment[(int) seg]));
  1112.  
  1113. }
  1114.  
  1115. void
  1116. md_apply_fix (fixP, val)
  1117.      fixS *fixP;
  1118.      long val;
  1119. {
  1120.   char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
  1121.   int addr = fixP->fx_frag->fr_address + fixP->fx_where;
  1122.   if (fixP->fx_r_type == 0)
  1123.     {
  1124.       fixP->fx_r_type = R_SH_IMM32 ;
  1125.     }
  1126.  
  1127.   switch (fixP->fx_r_type)
  1128.     {
  1129.       
  1130.     case R_SH_IMM4:
  1131.       *buf = (*buf & 0xf0) | (val & 0xf);
  1132.       break;
  1133.  
  1134.     case R_SH_IMM4BY2:
  1135.       *buf = (*buf & 0xf0) | ((val>>1) & 0xf);
  1136.       break;
  1137.  
  1138.     case R_SH_IMM4BY4:
  1139.       *buf = (*buf & 0xf0) | ((val>>2) & 0xf);
  1140.       break;
  1141.  
  1142.     case R_SH_IMM8BY2:
  1143.       *buf = val >>1;
  1144.       break;
  1145.  
  1146.     case R_SH_IMM8BY4:
  1147.       *buf = val >>2;
  1148.       break;
  1149.  
  1150.     case R_SH_IMM8:
  1151.       *buf++ = val;
  1152.       break;
  1153.  
  1154.     case R_SH_PCRELIMM8BY4:
  1155.       addr &= ~1;
  1156.       
  1157.       if (val & 0x3)
  1158.     as_warn("non aligned displacement at %x\n", addr);
  1159.       val -=(addr+4);
  1160.       val+=3;
  1161.       val /= 4;
  1162.       if (val & ~0xff)
  1163.     as_warn("pcrel too far at %x\n", addr);
  1164.       
  1165.       *buf = val ;
  1166.       break;
  1167.  
  1168.     case R_SH_PCRELIMM8BY2:
  1169.       addr &= ~1;
  1170.       if (val & 0x1)
  1171.     as_bad("odd displacement at %x\n", addr);
  1172.       val -= (addr+4);
  1173.       val++;
  1174.       val /= 2;
  1175.       if (val & ~0xff)
  1176.     as_warn("pcrel too far at %x\n", addr);
  1177.       *buf= val;
  1178.       break;
  1179.  
  1180.     case R_SH_IMM32:
  1181.       *buf++ = val >>24;
  1182.       *buf++ = val >>16;
  1183.       *buf++ = val >>8;
  1184.       *buf++ = val >>0;
  1185.       break;
  1186.  
  1187.     default:
  1188.       abort ();
  1189.     }
  1190. }
  1191.  
  1192. void
  1193. DEFUN (md_operand, (expressionP), expressionS * expressionP)
  1194. {
  1195. }
  1196.  
  1197. int md_long_jump_size;
  1198.  
  1199. /*
  1200. called just before address relaxation, return the length
  1201. by which a fragment must grow to reach it's destination
  1202. */
  1203. int
  1204. md_estimate_size_before_relax (fragP, segment_type)
  1205.      register fragS *fragP;
  1206.      register segT segment_type;
  1207. {
  1208.   switch (fragP->fr_subtype)
  1209.     {
  1210.     case C(UNCOND_JUMP, UNDEF_DISP):
  1211.       /* used to be a branch to somewhere which was unknown */
  1212.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  1213.     {
  1214.       fragP->fr_subtype = C (UNCOND_JUMP, UNCOND12);
  1215.       fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND12)].rlx_length;
  1216.     }
  1217.       else
  1218.     {
  1219.       fragP->fr_subtype = C (UNCOND_JUMP, UNDEF_WORD_DISP);
  1220.       fragP->fr_var = md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
  1221.       return md_relax_table[C (UNCOND_JUMP, UNCOND32)].rlx_length;
  1222.     }
  1223.       break; 
  1224.       
  1225.     default:
  1226.       abort ();
  1227.     case C (COND_JUMP, UNDEF_DISP):
  1228.       /* used to be a branch to somewhere which was unknown */
  1229.       if (S_GET_SEGMENT (fragP->fr_symbol) == segment_type)
  1230.     {
  1231.       /* Got a symbol and it's defined in this segment, become byte
  1232.      sized - maybe it will fix up */
  1233.       fragP->fr_subtype = C (COND_JUMP, COND8);
  1234.       fragP->fr_var = md_relax_table[C (COND_JUMP, COND8)].rlx_length;
  1235.     }
  1236.       else
  1237.     {
  1238.       /* Its got a segment, but its not ours, so it will always be long */
  1239.       fragP->fr_subtype = C (COND_JUMP, UNDEF_WORD_DISP);
  1240.       fragP->fr_var = md_relax_table[C (COND_JUMP, COND32)].rlx_length;
  1241.       return md_relax_table[C (COND_JUMP, COND32)].rlx_length;
  1242.     }
  1243.       break; 
  1244.     }
  1245.   return fragP->fr_var;
  1246. }
  1247.  
  1248. /* Put number into target byte order */
  1249.  
  1250. void
  1251. md_number_to_chars (ptr, use, nbytes)
  1252.      char *ptr;
  1253.      long use;
  1254.      int nbytes;
  1255. {
  1256.   switch (nbytes)
  1257.     {
  1258.     case 4:
  1259.       *ptr++ = (use >> 24) & 0xff;
  1260.     case 3:
  1261.       *ptr++ = (use >> 16) & 0xff;
  1262.     case 2:
  1263.       *ptr++ = (use >> 8) & 0xff;
  1264.     case 1:
  1265.       *ptr++ = (use >> 0) & 0xff;
  1266.       break;
  1267.     default:
  1268.       abort ();
  1269.     }
  1270. }
  1271. long
  1272. md_pcrel_from (fixP)
  1273.      fixS *fixP;
  1274.  
  1275. {
  1276.   int gap = fixP->fx_size + fixP->fx_where +
  1277.     fixP->fx_frag->fr_address;
  1278.   return gap;  
  1279. }
  1280.  
  1281. void
  1282. tc_coff_symbol_emit_hook ()
  1283. {
  1284. }
  1285.  
  1286. short
  1287. tc_coff_fix2rtype (fix_ptr)
  1288.      fixS *fix_ptr;
  1289. {
  1290.   return fix_ptr->fx_r_type;
  1291. }
  1292.  
  1293. void
  1294. tc_reloc_mangle (fix_ptr, intr, base)
  1295.      fixS *fix_ptr;
  1296.      struct internal_reloc *intr;
  1297.      bfd_vma base;
  1298.  
  1299. {
  1300.   symbolS *symbol_ptr;
  1301.  
  1302.   symbol_ptr = fix_ptr->fx_addsy;
  1303.  
  1304.   /* If this relocation is attached to a symbol then it's ok
  1305.      to output it */
  1306.   if (fix_ptr->fx_r_type == RELOC_32)
  1307.     {
  1308.       /* cons likes to create reloc32's whatever the size of the reloc..
  1309.        */
  1310.       switch (fix_ptr->fx_size)
  1311.     {
  1312.     case 2:
  1313.       intr->r_type = R_IMM16;
  1314.       break;
  1315.     case 1:
  1316.       intr->r_type = R_IMM8;
  1317.       break;
  1318.     default:
  1319.       abort ();
  1320.     }
  1321.     }
  1322.   else
  1323.     {
  1324.       intr->r_type = fix_ptr->fx_r_type;
  1325.     }
  1326.  
  1327.   intr->r_vaddr = fix_ptr->fx_frag->fr_address + fix_ptr->fx_where + base;
  1328.   intr->r_offset = fix_ptr->fx_offset;
  1329.  
  1330.   /* Turn the segment of the symbol into an offset.  */
  1331.   if (symbol_ptr)
  1332.     {
  1333.       symbolS *dot;
  1334.  
  1335.       dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
  1336.       if (dot)
  1337.     {
  1338.       intr->r_offset += S_GET_VALUE (symbol_ptr);
  1339.       intr->r_symndx = dot->sy_number;
  1340.     }
  1341.       else
  1342.     {
  1343.       intr->r_symndx = symbol_ptr->sy_number;
  1344.     }
  1345.     }
  1346.   else
  1347.     {
  1348.       intr->r_symndx = -1;
  1349.     }
  1350. }
  1351.  
  1352. int
  1353. tc_coff_sizemachdep(frag)
  1354. fragS *frag;
  1355. {
  1356.   return md_relax_table[frag->fr_subtype].rlx_length;
  1357. }  
  1358. /* end of tc-sh.c */
  1359.